//
//  ViewController.m
//  LockDemo
//
//  Created by administrator on 2019/3/12.
//  Copyright © 2019年 administrator.a.c. All rights reserved.
//

#import "ViewController.h"
#import <pthread.h>
//#import <osato>

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    [self conditionLockLock];
}

#pragma mark ------------------ synchronized
/**
 @synchronized(obj)指令使用的obj为该锁的唯一标识，只有当标识相同时，才为满足互斥，如果线程2中的@synchronized(obj)改为@synchronized(self),刚线程2就不会被阻塞，@synchronized指令实现锁的优点就是我们不需要在代码中显式的创建锁对象，便可以实现锁的机制，但作为一种预防措施，@synchronized块会隐式的添加一个异常处理例程来保护代码，该处理例程会在异常抛出的时候自动的释放互斥锁。所以如果不想让隐式的异常处理例程带来额外的开销，你可以考虑使用锁对象。
 */
- (void)synchronizedLock {
    NSObject * obj = NSObject.alloc.init;
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        @synchronized(obj) {
            NSLog(@"需要线程同步的操作1  开始");
            sleep(3);
            NSLog(@"需要线程同步的操作1   结束");
        }
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        sleep(1);
        @synchronized(obj) {
            NSLog(@"需要线程同步的操作2");
        }
    });
    
    /**
     需要线程同步的操作1 开始
     需要线程同步的操作1 结束
     需要线程同步的操作2
     */
}




#pragma mark ------------------ semaphore
/**
 如果dsema信号量的值大于0，该函数所处线程就继续执行下面的语句，并且将信号量的值减1；如果desema的值为0，那么这个函数就阻塞当前线程等待timeout（注意timeout的类型为dispatch_time_t，不能直接传入整形或float型数），如果等待的期间desema的值被dispatch_semaphore_signal函数加1了，且该函数（即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行其后语句。
 dispatch_semaphore 是信号量，但当信号总量设为 1 时也可以当作锁来。在没有等待情况出现时，它的性能比 pthread_mutex 还要高，但一旦有等待情况出现时，性能就会下降许多。相对于 OSSpinLock 来说，它的优势在于等待时不会消耗 CPU 资源。
 */
- (void)semaphoreLock {
    dispatch_semaphore_t signal = dispatch_semaphore_create(1);     //初始信号量为1
    dispatch_time_t overTime = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC); //锁几秒
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        dispatch_semaphore_wait(signal, overTime);      //信号量减1
        NSLog(@"需要线程同步的操作1  开始");
        sleep(2);
        NSLog(@"需要线程同步的操作1  结束");
        dispatch_semaphore_signal(signal);          //信号量加1
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        dispatch_semaphore_wait(signal, overTime);
        dispatch_semaphore_signal(signal);
    });
    
    /**
     需要线程同步的操作1 开始
     需要线程同步的操作1 结束
     需要线程同步的操作2
     
     如果超时时间overTime设置成>2，可完成同步操作。如果overTime<2的话，在线程1还没有执行完成的情况下，此时超时了，将自动执行下面的代码。
     需要线程同步的操作1 开始
     需要线程同步的操作2
     需要线程同步的操作1 结束
    */
}






#pragma mark ------------------ NSLock
/**
 NSLock是Cocoa提供给我们最基本的锁对象，这也是我们经常所使用的，除lock和unlock方法外，NSLock还提供了tryLock和lockBeforeDate:两个方法，前一个方法会尝试加锁，如果锁不可用(已经被锁住)，刚并不会阻塞线程，并返回NO。lockBeforeDate:方法会在所指定Date之前尝试加锁，如果在指定时间之前都不能加锁，则返回NO。
 */
- (void)nslockLock {
    NSLock * lock = NSLock.alloc.init;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//        [lock lock];
        [lock lockBeforeDate:NSDate.date];
        NSLog(@"需要线程同步的操作1  开始");
        sleep(2);
        NSLog(@"需要线程同步的操作1  结束");
        [lock unlock];
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        if (lock.tryLock) { //尝试获取锁，如果获取不到返回NO,不会阻塞
            NSLog(@"未上锁");
            [lock unlock];
        }else {
            NSLog(@"已被上锁");
        }
        
        NSDate *date = [NSDate.alloc initWithTimeIntervalSinceNow:3];
        if ([lock lockBeforeDate:date]) {
            NSLog(@"没有超时，获得锁");
            [lock unlock];
        }
        else {
            NSLog(@"超时，没有获得锁");
        }
    });
    
    /**
     需要线程同步的操作1 开始
     已被上锁
     需要线程同步的操作1 结束
     没有超时，获得锁
     */
}







#pragma mark ------------------ NSRecursiveLock     递归锁
/**
 NSRecursiveLock实际上定义的是一个递归锁，这个锁可以被同一线程多次请求，而不会引起死锁。这主要是用在循环或递归操作中。
 这段代码是一个典型的死锁情况。在我们的线程中，RecursiveMethod是递归调用的。所以每次进入这个block时，都会去加一次锁，而从第二次开始，由于锁已经被使用了且没有解锁，所以它需要等待锁被解除，这样就导致了死锁，线程被阻塞住了。
 
 使用NSRecursiveLock。它可以允许同一线程多次加锁，而不会造成死锁。递归锁会跟踪它被lock的次数。每次成功的lock都必须平衡调用unlock操作。只有所有达到这种平衡，锁最后才能被释放，以供其它线程使用。
 */
- (void)recursiveLock {
//    NSLock * lock = NSLock.alloc.init;      //使用nslock会产生死锁
    NSRecursiveLock * lock = NSRecursiveLock.alloc.init;
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        static void (^RecursiveMethod)(int);
        
        RecursiveMethod = ^(int value) {
            [lock lock];
            if (value > 0) {
                NSLog(@"value = %@",@(value));
                sleep(1);
                RecursiveMethod(value - 1);
            }
            [lock unlock];
        };
        
        RecursiveMethod(6);
    });
    
    /**
     value = 6
     value = 5
     value = 4
     value = 3
     value = 2
     value = 1
     */
}






#pragma mark ------------------ NSConditionLock 条件锁
/**
 - (void)lockWhenCondition:(NSInteger)condition;
 - (void)unlockWithCondition:(NSInteger)condition;
 这两个condition一样的时候会相互通知。
 
 1、初始化 self.condition = [[NSConditionLock alloc]initWithCondition:0];
 2、获得锁 [self.condition lockWhenCondition:1];
 3、解锁 [self.condition unlockWithCondition:1];
 
 
 */
- (void)conditionLockLock {
    NSConditionLock * lock = [NSConditionLock.alloc initWithCondition:0];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        while (YES) {
            [lock lockWhenCondition:1];
            NSLog(@"需要线程同步的操作1 开始");
            sleep(2);
            NSLog(@"需要线程同步的操作1 结束");
            [lock unlockWithCondition:0];
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        while (YES) {
            [lock lockWhenCondition:0];
            NSLog(@"需要线程同步的操作2 开始");
            sleep(1);
            NSLog(@"需要线程同步的操作2 结束");
            [lock unlockWithCondition:2];
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        while (YES) {
            [lock lockWhenCondition:2];
            NSLog(@"需要线程同步的操作3 开始");
            sleep(1);
            NSLog(@"需要线程同步的操作3 结束");
            [lock unlockWithCondition:1];
        }
    });
    
    /**
     需要线程同步的操作2 开始
     需要线程同步的操作2 结束
     需要线程同步的操作3 开始
     需要线程同步的操作3 结束
     需要线程同步的操作1 开始
     需要线程同步的操作1 结束
     */
}




#pragma mark ------------------ NSContidion
/**
 一种最基本的条件锁。手动控制线程wait和signal。
 [condition lock];一般用于多线程同时访问、修改同一个数据源，保证在同一时间内数据源只被访问、修改一次，其他线程的命令需要在lock 外等待，只到unlock ，才可访问
 [condition unlock];与lock 同时使用
 [condition wait];让当前线程处于等待状态
 [condition signal];CPU发信号告诉线程不用在等待，可以继续执行
 
 */
- (void)contidionLock {
    NSCondition * condition = NSCondition.alloc.init;
    NSMutableArray * products = NSMutableArray.array;
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        while (YES) {
            [condition lock];
            if (products.count == 0) {
                NSLog(@"wait for product");
                [condition wait];
            }
            [products removeObjectAtIndex:0];
            NSLog(@"custome a product");
            [condition unlock];
        }
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        while (YES) {
            [condition lock];
            [products addObject:NSObject.alloc.init];
            NSLog(@"produce a product，总量：%ld",products.count);
            [condition signal];
            [condition unlock];
            sleep(2);
        }
    });
    
    /**
     wait for product
     produce a product，总量：1
     custome a product
     
     wait for product
     produce a product，总量：1
     custome a product
     */
}





#pragma mark ------------------ pthread_mutex
/**
 c语言定义下多线程加锁方式。
 1：pthread_mutex_init(pthread_mutex_t * mutex,const pthread_mutexattr_t attr);
 初始化锁变量mutex。attr为锁属性，NULL值为默认属性。
 2：pthread_mutex_lock(pthread_mutex_t* mutex);加锁
 3：pthread_mutex_tylock(pthread_mutex_t* mutex);加锁，但是与2不一样的是当锁已经在使用的时候，返回为EBUSY，而不是挂起等待。
 4：pthread_mutex_unlock(pthread_mutex_t* mutex);释放锁
 5：pthread_mutex_destroy(pthread_mutex_t* *mutex);使用完后释放
 */
- (void)pthread_mutexLock {
    __block pthread_mutex_t theLock ;
    pthread_mutex_init(&theLock, NULL);
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        pthread_mutex_lock(&theLock);
        NSLog(@"需要线程同步的操作1 开始");
        sleep(3);
        NSLog(@"需要线程同步的操作1 结束");
        pthread_mutex_unlock(&theLock);
        
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        sleep(1);
        pthread_mutex_lock(&theLock);
        NSLog(@"需要线程同步的操作2");
        pthread_mutex_unlock(&theLock);
    });
    
    /**
     需要线程同步的操作1 开始
     需要线程同步的操作1 结束
     需要线程同步的操作2
     */
}

#pragma mark --------------------------- pthread_mutex(recursive) 递归锁
/**
 这是pthread_mutex为了防止在递归的情况下出现死锁而出现的递归锁。作用和NSRecursiveLock递归锁类似。
 如果使用pthread_mutex_init(&theLock, NULL);初始化锁的话，上面的代码会出现死锁现象。如果使用递归锁的形式，则没有问题。
 
 PTHREAD_MUTEX_NORMAL 缺省类型，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后先进先出原则获得锁。
 PTHREAD_MUTEX_ERRORCHECK 检错锁，如果同一个线程请求同一个锁，则返回 EDEADLK，否则与普通锁类型动作相同。这样就保证当不允许多次加锁时不会出现嵌套情况下的死锁。
 PTHREAD_MUTEX_RECURSIVE 递归锁，允许同一个线程对同一个锁成功获得多次，并通过多次 unlock 解锁。
 PTHREAD_MUTEX_DEFAULT 适应锁，动作最简单的锁类型，仅等待解锁后重新竞争，没有等待队列。
 
 */
- (void)pthread_mutexrecursiveLock {
    __block pthread_mutex_t theLock;
    
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);      //设置type未递归
    pthread_mutex_init(&theLock, &attr);
    pthread_mutexattr_destroy(&attr);
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        static void (^RecursiveMethod)(int);
        
        RecursiveMethod = ^(int value) {
            pthread_mutex_lock(&theLock);
            if (value > 0) {
                NSLog(@"value = %@",@(value));
                sleep(1);
                RecursiveMethod(value - 1);
            }
            pthread_mutex_unlock(&theLock);
        };
        
        RecursiveMethod(5);
    });
    
    /**
     value = 5
     value = 4
     value = 3
     value = 2
     value = 1
     */
}

#pragma mark - OSSpinLock
/**
 OSSpinLock 自旋锁，性能最高的锁。原理很简单，就是一直 do while 忙等。它的缺点是当等待时会消耗大量 CPU 资源，所以它不适用于较长时间的任务。 不过最近YY大神在自己的博客不再安全的 OSSpinLock中说明了OSSpinLock已经不再安全，请大家谨慎使用。

- (void)osspinLock {
    _block OSSpinLock theLock = OS_SPINLOCK_INIT;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        OSSpinLockLock(&theLock);
        NSLog(@"需要线程同步的操作1 开始");
        sleep(3);
        NSLog(@"需要线程同步的操作1 结束");
        OSSpinLockUnlock(&theLock);
        
    });
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        OSSpinLockLock(&theLock);
        sleep(1);
        NSLog(@"需要线程同步的操作2");
        OSSpinLockUnlock(&theLock);
        
    });
}
 */


- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}


@end
